home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Controls / Visual Basic Controls.iso / vbcontrol / sheriffa / slsapi.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1999-04-18  |  12.4 KB  |  380 lines
  1. unit SlsApi;
  2.  
  3. {$ALIGN OFF}
  4.  
  5. interface
  6.  
  7. {Challenge protocol}
  8. Const SLS_NO_PROTOCOL = $0;
  9. Const SLS_BASIC_PROTOCOL = $1;
  10.  
  11. {state of licence}
  12. Const SLS_STATE_UNDEFINED = $0;      {Licence type and contents to be specified}
  13. Const SLS_STATE_BAD = $1;            {Licence has being illegally modified}
  14. Const SLS_STATE_EXPIRED = $2;        {Licence has expired}
  15. Const SLS_STATE_EXHAUSTED = $3;      {Licence units has run out}
  16. Const SLS_STATE_OK = $8;             {Licence is valid}
  17.  
  18. {type of licence}
  19. Const SLS_TYPE_UNDEFINED   = $0;     {Undefined}
  20. Const SLS_TYPE_UNIT_METER  = $1;     {Unit Metering}
  21. Const SLS_TYPE_TIME_METER  = $2;     {Time Metering}
  22. Const SLS_TYPE_EXPIRATION  = $4;     {Expiry Control}
  23. Const SLS_TYPE_CONCURRENCY = $8;     {Concurrency Control}
  24. Const SLS_TYPE_UNLIMITED  = $10;     {Unlimited/Unrestricted}
  25. Const SLS_TYPE_LIFETIME_KEY = $100;  {lifetime key}
  26. Const SLS_TYPE_LIFETIME_REF = $200;  {lifetime reference}
  27. Const SLS_TYPE_UNEXPORTABLE = $400;  {lifetime key}
  28.  
  29. {Everything is fine}
  30. Const SLS_SUCCESS = $0;
  31. {General Error (unknown error)}
  32. Const SLS_ERROR = $80041000;
  33.  
  34. {Error Codes}
  35. {System Error}
  36. Const SLS_E_SYSTEM_ERROR = $80041001;
  37. {Invalid Product Code}
  38. Const SLS_E_PRODUCT_CODE = $80041002;
  39. {Invalid Reference Code}
  40. Const SLS_E_REFERENCE_CODE = $80041003;
  41. {Invalid Machine Code}
  42. Const SLS_E_MACHINE_CODE = $80041004;
  43. {Invalid System Time}
  44. Const SLS_E_SYSTEM_TIME = $80041005;
  45. {Not Enough Memory}
  46. Const SLS_E_OUT_OF_MEMORY = $80041006;
  47. {Not Enough Handle}
  48. Const SLS_E_OUT_OF_HANDLE = $80041007;
  49. {Illegal Challenge}
  50. Const SLS_E_CHALLENGE_ILLEGAL = $80041008;
  51. {Unsuported challenge}
  52. Const SLS_E_CHALLENGE_UNSUPORTED = $80041009;
  53. {Connction Sink ID invalid}
  54. Const SLS_E_CONNECTION_ID = $8004100A;
  55. {Invalid Queue Number}
  56. Const SLS_E_QUEUE_NUMBER = $8004100B;
  57. {Queue Too Long}
  58. Const SLS_E_QUEUE_TOO_LONG = $8004100C;
  59. {Failed To Locate Database Path}
  60. Const SLS_E_DATABASE_PATH = $8004100D;
  61. {Invalid SuitID}
  62. Const SLS_E_SUIT_ID = $8004100E;
  63. {Unregistered Suit}
  64. Const SLS_E_SUIT_UNREGISTERED = $8004100F;
  65. {Invalid Augument passed to function}
  66. Const SLS_E_AUGUMENT_INVALID = $80041010;
  67. {Invalid Handle}
  68. Const SLS_E_LICENCE_HANDLE = $80041011;
  69. {Unregistered product/licence}
  70. Const SLS_E_LICENCE_UNREGISTERED = $80041012;
  71. {Licence Undefined}
  72. Const SLS_E_LICENCE_UNDEFINED = $80041013;
  73. {Licence (run out of cocurrent users)}
  74. Const SLS_E_LICENCE_EXCEEDED = $80041014;
  75. {Licence Exhausted (run out of meter units)}
  76. Const SLS_E_LICENCE_EXHAUSTED = $80041015;
  77. {Licence Expired}
  78. Const SLS_E_LICENCE_EXPIRED = $80041016;
  79. {Licence Invalid (corrupted, tamped)}
  80. Const SLS_E_LICENCE_INVALID = $80041017;
  81. {Licence Suspended}
  82. Const SLS_E_LICENCE_SUSPENDED = $80041018;
  83. {Licence Terminated}
  84. Const SLS_E_LICENCE_TERMINATED = $80041019;
  85. {Licence Unavaliable}
  86. Const SLS_E_LICENCE_UNAVAILABLE = $8004101A;
  87. {Licence unit not defined}
  88. Const SLS_E_UNIT_UNDEFINED = $8004101B;
  89. {Licence unit shortage (units been reserved)}
  90. Const SLS_E_UNIT_EXCEEDED = $8004101C;
  91. {Index used to enumerate products}
  92. Const SLS_E_PRODUCT_INDEX = $8004101D;
  93. {Bad Secret}
  94. Const SLS_E_BAD_SECRET = $8004101E;
  95. {Bad MAC(Message Authentication Code)}
  96. Const SLS_E_BAD_MAC = $8004101F;
  97.  
  98. {Licence File Error(used by Sheriff only)}
  99. {The file could not be located.}
  100. Const SLS_E_FILE_NOT_FOUND = $80041020;
  101. {All or part of the path is invalid.}
  102. Const SLS_E_FILE_BAD_PATH = $80041021;
  103. {The permitted number of open files was exceeded.}
  104. Const SLS_E_FILE_TOO_MANY = $80041022;
  105. {The file could not be accessed}
  106. Const SLS_E_FILE_ACCESS_DENIED = $80041023;
  107. {There was an attempt to use an invalid file handle.}
  108. Const SLS_E_FILE_BAD_HANDLE = $80041024;
  109. {There was an error trying to set the file pointer.}
  110. Const SLS_E_FILE_BAD_SEEK = $80041025;
  111. {There was a hardware error.}
  112. Const SLS_E_FILE_HARDIO = $80041026;
  113. {SHARE.EXE was not loaded, or a shared region was locked.}
  114. Const SLS_E_FILE_SHARING = $80041027;
  115. {There was an attempt to lock a region that was already locked.}
  116. Const SLS_E_FILE_LOCKING = $80041028;
  117. {The disk is full.}
  118. Const SLS_E_FILE_DISK_FULL = $80041029;
  119. {The end of file was reached.}
  120. Const SLS_E_FILE_EOF = $8004102A;
  121. {CRC error}
  122. Const SLS_E_FILE_BAD_CRC = $8004102B;
  123. {Signature error}
  124. Const SLS_E_FILE_BAD_SIGNATURE = $8004102C;
  125. {Corruption}
  126. Const SLS_E_FILE_BAD_DATA = $8004102D;
  127. {Disk Signature error}
  128. Const SLS_E_DISK_BAD_SIGNATURE = $8004102E;
  129.  
  130. {Invalid Licence Path}
  131. Const SLS_E_PATH_INVALID = $80041030;
  132. {Failed to create licecne path}
  133. Const SLS_E_PATH_CREATE = $80041031;
  134. {Access(Read/Write) Denied}
  135. Const SLS_E_PATH_ACCESS_DENIED = $80041032;
  136. {Registery operation failure}
  137. Const SLS_E_REG_FAILURE = $80041033;
  138. {Licence File been tampered}
  139. Const SLS_E_BAD_LICENCE = $80041034;
  140. {Registry has been tampered}
  141. Const SLS_E_BAD_REGISTRY = $80041035;
  142. {Machine Signature is wrong}
  143. Const SLS_E_BAD_MACHINE = $80041036;
  144. {Failed to get machine code}
  145. Const SLS_E_OP_MACHINE_CODE = $80041037;
  146. {Failed to get machine signature}
  147. Const SLS_E_OP_MACHINE_SIGN = $80041038;
  148. {Failed to get file signature}
  149. Const SLS_E_OP_FILE_SIGN = $80041039;
  150. {Failed to get disk signature}
  151. Const SLS_E_OP_DISK_SIGN = $8004103A;
  152.  
  153.  
  154. type
  155.  DWORD=LongInt;
  156.  HRESULT=LongInt;
  157.  SLS_HANDLE=DWORD;
  158.  
  159.  SLS_DATE = record
  160.    Year:  DWORD;
  161.    Month: DWORD;
  162.    Day:   DWORD;
  163.  end;
  164.  
  165.  SLS_LICENCE = record
  166.     LicenceType:DWORD;        {type of licence}
  167.     Meter:      DWORD;        {for metering, e.g. Unit, Time mertering}
  168.     EndDate:    SLS_DATE;    {for expiration date}
  169.     CoUsers:    DWORD;        {Concurrent users}
  170.     AccessKey:  DWORD;        {Access control key}
  171.  end;
  172.  
  173.  SLS_REQUEST = record
  174.     UnitsReserved:DWORD;
  175.  end;
  176.  
  177.  SLS_PERMIT = record
  178.     UnitsGranted:DWORD;
  179.     AccessKey:DWORD;
  180.  end;
  181.  
  182.  SLS_UPDATE = record
  183.     UnitsReserved:DWORD;
  184.     UnitsConsumed:DWORD;
  185.  end;
  186.  
  187.  SLS_RELEASE = record
  188.     UnitsConsumed:DWORD;
  189.  end;
  190.  
  191.  {types for challenging}
  192.  SLS_MSG_DIGEST = record
  193.     MessageDigest: array[0..15] of char;    {binary data}
  194.  end;
  195.  
  196.  SLS_CHALLDATA = record
  197.     SecretIndex:DWORD;
  198.     Random:DWORD;
  199.     MsgDigest:SLS_MSG_DIGEST;
  200.  end;
  201.  
  202.  SLS_CHALLENGE = record
  203.     Protocol:DWORD;
  204.     Size:DWORD;
  205.     ChallengeData:SLS_CHALLDATA;
  206.  end;
  207.  
  208.  {Secret used for challenge}
  209.  SLS_SECRET = record
  210.     Secret:array[0..31] of char;
  211.  end;
  212.  
  213.  SLS_LICENCE_INFO = record
  214.     {Licence Part}
  215.     LicenceType:DWORD;        {type of licence}
  216.     Meter:      DWORD;        {Units or Days limit}
  217.     EndDate:    SLS_DATE;    {Expiration date}
  218.     CoUsers:    DWORD;        {Concurrent users}
  219.     AccessKey:  DWORD;        {Access control key}
  220.     {Usage Part}
  221.     State:      DWORD;        {State of licence}
  222.     MeterUsage: DWORD;        {for metering only(units used, days used)}
  223.     StartDate:  SLS_DATE;    {Start date}
  224.     ActiveUsers:DWORD;      {Number of active users}
  225.  end;
  226.  
  227.  SLS_OPTIONS = record
  228.     MinReclaimTime:DWORD;
  229.     MaxReclaimTime:DWORD;
  230.     Reserved1:DWORD;
  231.     Reserved2:DWORD;
  232.  end;
  233.  
  234.  function SLS_Register( pszProductID:PChar;
  235.                         pszProductName:PChar;
  236.                         pszLicencePath:PChar):HRESULT; stdcall;
  237.  function SLS_Licenses(pszProductID:PChar;
  238.                       var pLicence:SLS_LICENCE;
  239.                       var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  240.  
  241.  function SLS_Requests(pszProductID:PChar;
  242.                      pszUserName:PChar;
  243.                      var pRequest:SLS_REQUEST;
  244.                      var pPermit:SLS_PERMIT;
  245.                      var plLicenceHandle:SLS_HANDLE;
  246.                      var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  247.  
  248.  function SLS_Updates(pszProductID:PChar;
  249.                      lLicenceHandle:SLS_HANDLE;
  250.                      var pUpdate:SLS_UPDATE;
  251.                      var pPermit:SLS_PERMIT;
  252.                      var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  253.  
  254.  function SLS_Releases(pszProductID:PChar;
  255.                      lLicenceHandle:SLS_HANDLE;
  256.                      var pRelease:SLS_RELEASE;
  257.                      var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  258.  
  259.  function SLS_GetReference(pszProductID:PChar;
  260.                            var pszReference:array of char):HRESULT; stdcall;
  261.  
  262.  function SLS_SetLicence(pszProductID:PChar;
  263.                          pszReference:PChar;
  264.                          pszLicenceKey:PChar):HRESULT; stdcall;
  265.  
  266.  function SLS_QueryLicenceInfo(pszProductID:PChar;
  267.                         var pLicenceInfo:SLS_LICENCE_INFO):HRESULT; stdcall;
  268.  
  269.  //Challenge
  270.  function SLS_CreateChallenge(
  271.                       SecretArray:Pointer;
  272.                       nSecrectSize:Integer;
  273.                       pbStream:Pointer;
  274.                       nStreamSize:Integer;
  275.                       var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  276.  
  277.  function SLS_VerifyChallenge(
  278.                       SecretArray:Pointer;
  279.                       nSecrectSize:Integer;
  280.                       pbStream:Pointer;
  281.                       nStreamSize:Integer;
  282.                       var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  283.  
  284.  {SLS_GetErrorMessage
  285.   Get Error Mesaage. pszErrorMessage points to buffer allocated by caller,
  286.   the minimum length of the buffer is 256 bytes}
  287.  function SLS_GetErrorMessage(hr:HRESULT;pszErrorMessage:PChar):HRESULT; stdcall;
  288.  
  289.  {Others}
  290.  function SLS_IsProductInstalled(pszProductID:PChar):HRESULT; stdcall;
  291.  function SLS_SetReclaimTime(nMinutes:Integer):HRESULT; stdcall;
  292.  
  293. implementation
  294.  function SLS_Register( pszProductID:PChar;
  295.                         pszProductName:PChar;
  296.                         pszLicencePath:PChar):Longint; stdcall;
  297.  external 'slsapi.dll';
  298.  
  299.  function SLS_Licenses(pszProductID:PChar;
  300.                       var pLicence:SLS_LICENCE;
  301.                       var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  302.  external 'slsapi.dll' name 'SLS_License';
  303.  
  304.  function SLS_Requests(pszProductID:PChar;
  305.                      pszUserName:PChar;
  306.                      var pRequest:SLS_REQUEST;
  307.                      var pPermit:SLS_PERMIT;
  308.                      var plLicenceHandle:SLS_HANDLE;
  309.                      var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  310.  external 'slsapi.dll' name 'SLS_Request';
  311.  
  312.  function SLS_Updates(pszProductID:PChar;
  313.                      lLicenceHandle:SLS_HANDLE;
  314.                      var pUpdate:SLS_UPDATE;
  315.                      var pPermit:SLS_PERMIT;
  316.                      var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  317.  external 'slsapi.dll' name 'SLS_Update';
  318.  
  319.  function SLS_Releases(pszProductID:PChar;
  320.                      lLicenceHandle:SLS_HANDLE;
  321.                      var pRelease:SLS_RELEASE;
  322.                      var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  323.  external 'slsapi.dll' name 'SLS_Release';
  324.  
  325.  function SLS_GetReference(pszProductID:PChar;
  326.                            var pszReference:array of char):HRESULT; stdcall;
  327.  external 'slsapi.dll';
  328.  
  329.  function SLS_SetLicence(pszProductID:PChar;
  330.                          pszReference:PChar;
  331.                          pszLicenceKey:PChar):HRESULT; stdcall;
  332.  external 'slsapi.dll';
  333.  
  334.  function SLS_QueryLicenceInfo(pszProductID:PChar;
  335.                         var pLicenceInfo:SLS_LICENCE_INFO):HRESULT; stdcall;
  336.  external 'slsapi.dll';
  337.  
  338.  //Challenge
  339.  function SLS_CreateChallenge(
  340.                       SecretArray:Pointer;
  341.                       nSecrectSize:Integer;
  342.                       pbStream:Pointer;
  343.                       nStreamSize:Integer;
  344.                       var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  345.  external 'slsapi.dll';
  346.  
  347.  function SLS_VerifyChallenge(
  348.                       SecretArray:Pointer;
  349.                       nSecrectSize:Integer;
  350.                       pbStream:Pointer;
  351.                       nStreamSize:Integer;
  352.                       var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  353.  external 'slsapi.dll';
  354.  
  355.  {SLS_GetErrorMessage
  356.   Get Error Mesaage. pszErrorMessage points to buffer allocated by caller,
  357.   the minimum length of the buffer is 256 bytes}
  358.  function SLS_GetErrorMessage(hr:HRESULT;pszErrorMessage:PChar):HRESULT; stdcall;
  359.  external 'slsapi.dll';
  360.  
  361.  {Others}
  362.  function SLS_IsProductInstalled(pszProductID:PChar):HRESULT; stdcall;
  363.  external 'slsapi.dll';
  364.  
  365.  function SLS_SetReclaimTime(nMinutes:Integer):HRESULT; stdcall;
  366.  external 'slsapi.dll';
  367.  
  368.  function SLS_SetOptions(pszProductID:PChar;
  369.                           lLicenceHandle:SLS_HANDLE;
  370.                           var pOptions:SLS_OPTIONS;
  371.                           var pChallenge:SLS_CHALLENGE):HRESULT; stdcall;
  372.  external 'slsapi.dll';
  373.  
  374.  function SLS_Terminate(pszProductID:PChar;
  375.                         var pszTerminationCode:array of char):HRESULT; stdcall;
  376.  external 'slsapi.dll';
  377.  
  378. end.
  379.  
  380.